home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 426-450 / disk_438 / gadgeted / source / gfunc.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  27KB  |  913 lines
  1. /*----------------------------------------------------------------------*
  2.   gfunc.c Version 2.0 -  © Copyright 1990 Jaba Development
  3.  
  4.   Author : Jan van den Baard
  5.   Purpose: functions called by user via menu and keyboard
  6.  *----------------------------------------------------------------------*/
  7.  
  8. extern struct Window        *MainWindow;
  9. extern struct Screen        *MainScreen;
  10. extern struct RastPort      *MainRP;
  11. extern struct GadgetList     Gadgets;
  12. extern struct ge_prefs       prefs;
  13. extern struct Gadget         TextGadget;
  14. extern struct NewWindow      nw_main;
  15. extern struct FileRequester *IODir;
  16. extern struct MemoryChain    Memory;
  17. extern BOOL                  Saved, REQUESTER, WBSCREEN;
  18. extern USHORT                FrontPen, Code, GadgetCount, id, BackFill;
  19. extern USHORT                Colors[32],DEPTH;
  20. extern UBYTE                 name[256], wdt[80], wlb[MAXLABEL];
  21. extern SHORT                 MainX,MainY,text_num;
  22. extern ULONG                 IDCMPFlags, WindowFlags, Class;
  23.  
  24. struct Gadget *wait_for_gadget();
  25.  
  26. /*
  27.  * remove all 'BORDERONLY' gadgets from the edit window
  28.  * so they won't interferre with your editing
  29.  */
  30. VOID rem_bo()
  31. {
  32.     register struct MyGadget *g;
  33.  
  34.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  35.  
  36.     for(g = Gadgets.Head; g->Succ; g = g->Succ)
  37.     {   if(TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  38.             RemoveGList(MainWindow,&g->Gadget,1);
  39.     }
  40. }
  41.  
  42. /*
  43.  * put back all 'BORDERONLY' gadgets in the edit window
  44.  * so they may be selected to be moved, re-sized, deleted,
  45.  * copied and edited
  46.  */
  47. VOID add_bo()
  48. {
  49.     register struct MyGadget *g;
  50.  
  51.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  52.  
  53.     for(g = Gadgets.Head; g->Succ; g = g->Succ)
  54.     {   if(TestBits((ULONG)g->SpecialFlags,BORDERONLY))
  55.             AddGList(MainWindow,&g->Gadget,-1L,1,NULL);
  56.     }
  57. }
  58.  
  59. /*
  60.  * refresh the complete display
  61.  */
  62. VOID refresh()
  63. {
  64.     add_bo();
  65.     SetDrMd(MainRP,JAM1);
  66.     if(REQUESTER)
  67.     {   SetAPen(MainRP,BackFill);
  68.         RectFill(MainRP,0,0,MainWindow->GZZWidth,MainWindow->GZZHeight);
  69.     }
  70.     else
  71.     {   SetAPen(MainRP,0);
  72.         RectFill(MainRP,0,0,MainWindow->Width,MainWindow->Height);
  73.     }
  74.     RefreshWindowFrame(MainWindow);
  75.     if(TextGadget.GadgetText) PrintIText(MainRP,TextGadget.GadgetText,0,0);
  76.     rem_bo();
  77. }
  78.  
  79. /*
  80.  * get the pointer to the MyGadget structure in which gadget 'g'
  81.  * is defined
  82.  */
  83. struct MyGadget *get_mg(g)
  84.     struct Gadget *g;
  85. {
  86.     register struct MyGadget *ret;
  87.  
  88.     for(ret = Gadgets.Head; ret ->Succ; ret = ret->Succ)
  89.         if(g == &ret->Gadget) return(ret);
  90. }
  91.  
  92. /*
  93.  * check to see if there are already gadgets on the
  94.  * edit window that are not 'BORDERONLY'
  95.  */
  96. BOOL is_gadget()
  97. {
  98.     register struct MyGadget *tmp;
  99.  
  100.     for(tmp = Gadgets.Head; tmp != (struct MyGadget *)&Gadgets.Tail; tmp = tmp->Succ)
  101.     {   if(NOT TestBits((ULONG)tmp->SpecialFlags,BORDERONLY)) return(TRUE);
  102.     }
  103.     return(FALSE);
  104. }
  105.  
  106. /*
  107.  * make a copy of a gadget
  108.  */
  109. VOID copy_gadget()
  110. {
  111.     struct Gadget *gad;
  112.     SHORT             x,y,w,h,xo,yo;
  113.     ULONG             ps;
  114.     struct MyGadget   *gadget, *mg;
  115.     struct Border     *border,*border1;
  116.     struct StringInfo *sinfo, *sinfo1;
  117.     struct PropInfo   *pinfo;
  118.     struct Image      *image, *image1;
  119.  
  120.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  121.     add_bo();
  122.     sst("PICK GADGET TO COPY....");
  123.     if(NOT(gad = wait_for_gadget(MainWindow)))
  124.     {   rem_bo();
  125.         return;
  126.     }
  127.  
  128.     Saved = FALSE;
  129.     mg = get_mg(gad);
  130.  
  131.     if(NOT(gadget = (struct MyGadget *)Alloc(&Memory,(ULONG)sizeof(struct MyGadget))))
  132.     {   Error("Out of Memory !");
  133.         return;
  134.     }
  135.  
  136.     un_grel(MainWindow,gad);
  137.     CopyMem((void *)gad,(void *)&gadget->Gadget,sizeof(struct Gadget));
  138.  
  139.     gadget->Gadget.GadgetText   = NULL;
  140.     gadget->Gadget.GadgetRender = NULL;
  141.     gadget->Gadget.SelectRender = NULL;
  142.     gadget->Gadget.SpecialInfo  = NULL;
  143.     gadget->Gadget.GadgetID     = GadgetCount++;
  144.     Format((char *)&gadget->GadgetLabel,"Gadget%ld",id++);
  145.     gadget->Gadget.LeftEdge     = gad->LeftEdge + 5;
  146.     gadget->Gadget.TopEdge      = gad->TopEdge  + 5;
  147.     gadget->SpecialFlags        = mg->SpecialFlags;
  148.  
  149.  
  150.     if(NOT TestBits((ULONG)gad->GadgetType,PROPGADGET))
  151.     {   if((NOT TestBits((ULONG)gad->Flags,GADGIMAGE)) OR
  152.            (NOT prefs.image_copy))
  153.         {   border = (struct Border *)gad->GadgetRender;
  154.             if(add_border(&gadget->Gadget) == FALSE)
  155.                 goto NoMem;
  156.             border1 = (struct Border *)gadget->Gadget.GadgetRender;
  157.             if(NOT TestBits((ULONG)gad->Flags,GADGIMAGE))
  158.             border1->FrontPen = border->FrontPen;
  159.         }
  160.     }
  161.     else
  162.     {   if(NOT(pinfo = (struct PropInfo *)Alloc(&Memory,(ULONG)sizeof(struct PropInfo))))
  163.             goto NoMem;
  164.         CopyMem((void *)gad->SpecialInfo,(void *)pinfo,sizeof(struct PropInfo));
  165.         if((NOT(TestBits((ULONG)gad->Flags,GADGIMAGE))) OR
  166.            (prefs.image_copy == FALSE))
  167.         {   if(NOT(gadget->Gadget.GadgetRender = Alloc(&Memory,(ULONG)sizeof(struct Image))))
  168.                 goto NoMem;
  169.             pinfo->Flags |= AUTOKNOB;
  170.         }
  171.         gadget->Gadget.SpecialInfo = (APTR)pinfo;
  172.     }
  173.  
  174.     if((TestBits((ULONG)gad->Flags,GADGIMAGE)) AND
  175.        (prefs.image_copy == TRUE))
  176.     {   image = (struct Image *)gad->GadgetRender;
  177.         ps = (ULONG)(RASSIZE(image->Width,image->Height) * image->Depth);
  178.         if(NOT(image1 = (struct Image *)Alloc(&Memory,(ULONG)sizeof(struct Image))))
  179.             goto NoMem;
  180.         CopyMem((void *)image,(void *)image1,sizeof(struct Image));
  181.         if(NOT(image1->ImageData = (USHORT *)AllocMem(ps,MEMF_CHIP+MEMF_CLEAR)))
  182.             goto NoMem;
  183.         CopyMem((void *)image->ImageData,(void *)image1->ImageData,ps);
  184.         gadget->Gadget.GadgetRender = (APTR)image1;
  185.     }
  186.     else if((TestBits((ULONG)gad->Flags,GADGIMAGE)) AND
  187.             (prefs.image_copy == FALSE))
  188.                   gadget->Gadget.Flags ^= GADGIMAGE;
  189.  
  190.     if((TestBits((ULONG)gad->Flags,GADGHIMAGE)) AND
  191.        (prefs.image_copy == TRUE) AND
  192.        (NOT TestBits((ULONG)gad->Flags,GADGHBOX)))
  193.     {   image = (struct Image *)gad->SelectRender;
  194.         ps = (ULONG)(RASSIZE(image->Width,image->Height) * image->Depth);
  195.         if(NOT(image1 = (struct Image *)Alloc(&Memory,(ULONG)sizeof(struct Image))))
  196.             goto NoMem;
  197.         CopyMem((void *)image,(void *)image1,sizeof(struct Image));
  198.         if(NOT(image1->ImageData = (USHORT *)AllocMem(ps,MEMF_CHIP+MEMF_CLEAR)))
  199.             goto NoMem;
  200.         CopyMem((void *)image->ImageData,(void *)image1->ImageData,ps);
  201.         gadget->Gadget.SelectRender = (APTR)image1;
  202.     }
  203.     else if((TestBits((ULONG)gad->Flags,GADGHIMAGE)) AND
  204.             (prefs.image_copy == FALSE))
  205.     {   gadget->Gadget.SelectRender = NULL;
  206.         gadget->Gadget.Flags ^= GADGHIMAGE;
  207.     }
  208.  
  209.     if((TestBits((ULONG)gad->GadgetType,STRGADGET)))
  210.     {   sinfo1 = (struct StringInfo *)gad->SpecialInfo;
  211.         if(NOT(sinfo = (struct StringInfo *)Alloc(&Memory,(ULONG)sizeof(struct StringInfo))))
  212.             goto NoMem;
  213.         CopyMem((void *)sinfo1,(void *)sinfo,sizeof(struct StringInfo));
  214.         if(NOT(sinfo->Buffer = (UBYTE *)Alloc(&Memory,sinfo->MaxChars)))
  215.             goto NoMem;
  216.         CopyMem((void *)sinfo1->Buffer,(void *)sinfo->Buffer,sinfo->MaxChars);
  217.         if(sinfo->UndoBuffer)
  218.         {   if(NOT(sinfo1->UndoBuffer = (UBYTE *)Alloc(&Memory,sinfo->MaxChars)))
  219.                 goto NoMem;
  220.         }
  221.         gadget->Gadget.SpecialInfo = (APTR)sinfo;
  222.     }
  223.     rem_bo();
  224.     set_info();
  225.     x = gadget->Gadget.LeftEdge-1;
  226.     y = gadget->Gadget.TopEdge-1;
  227.     w = gadget->Gadget.Width+1;
  228.     h = gadget->Gadget.Height+1;
  229.     SetDrMd(MainRP,COMPLEMENT);
  230.     SetAPen(MainRP,FrontPen);
  231.     draw_box(MainWindow,x,y,x+w,y+h);
  232.     do_info(x,y,x+w,y+w);
  233.     xo = MainX-x;
  234.     yo = MainY-y;
  235.     while(Code != SELECTDOWN)
  236.     {   while(read_msg(MainWindow))
  237.         {   if(Class == MENUPICK) set_info();
  238.             do_info(x,y,x+w,y+h);
  239.         }
  240.         get_xy(&MainX,&MainY);
  241.         if((MainX != (x + xo)) OR (MainY != (y + yo)))
  242.         {   draw_box(MainWindow,x,y,x+w,y+h);
  243.             x = MainX - xo;
  244.             y = MainY - yo;
  245.             draw_box(MainWindow,x,y,x+w,y+h);
  246.             do_info(x,y,x+w,y+w);
  247.         }
  248.     }
  249.     add_bo();
  250.     gadget->Gadget.LeftEdge = x+1;
  251.     gadget->Gadget.TopEdge  = y+1;
  252.     AddHead((void *)&Gadgets,(void *)gadget);
  253.     grel(MainWindow,&gadget->Gadget);
  254.     grel(MainWindow,gad);
  255.     AddGList(MainWindow,&gadget->Gadget,-1L,1,NULL);
  256.     rem_bo();
  257.     refresh();
  258.     return;
  259. NoMem:
  260.     FreeGadget(gadget);
  261.     Error("Out of Memory !");
  262. }
  263.  
  264. /*
  265.  * delete a gadget
  266.  */
  267. VOID delete()
  268. {
  269.     struct Gadget   *gd;
  270.     struct MyGadget *gadget;
  271.     UCOUNT          i=0;
  272.  
  273.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  274.  
  275.     add_bo();
  276.     sst("PICK GADGET TO DELETE.....");
  277.     if(NOT(gd = wait_for_gadget(MainWindow))) return;
  278.  
  279.     Saved = FALSE;
  280.  
  281.     for(gadget = Gadgets.Head; gadget->Succ; gadget = gadget->Succ)
  282.     {   if(gd == &gadget->Gadget)
  283.         {   Remove((void *)gadget);
  284.             un_grel(MainWindow,gd);
  285.             erase_gadget(MainWindow,gd);
  286.             RemoveGList(MainWindow,gd,1);
  287.             FreeGadget(gadget);
  288.             GadgetCount--;
  289.             break;
  290.         }
  291.     }
  292.     for(gadget = Gadgets.TailPred; gadget != (struct MyGadget *)&Gadgets.Head; gadget = gadget->Pred)
  293.        gadget->Gadget.GadgetID = i++;
  294.     rem_bo();
  295.     refresh();
  296. }
  297.  
  298. /*
  299.  * load a IFF ILBM brush as gadget render
  300.  */
  301. VOID render()
  302. {
  303.     struct Gadget   *gadget;
  304.     struct PropInfo *info;
  305.     struct Border   *border;
  306.     struct Image    *image, *image1, *ReadImage();
  307.     ULONG            Pos, ps, rc;
  308.  
  309.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  310.     if(NOT is_gadget()) return;
  311.     sst("PICK GADGET TO RENDER.....");
  312.     if(NOT(gadget = wait_for_gadget(MainWindow))) return;
  313.  
  314.     if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  315.     {   if(Ask("Gadget already has an Image !",
  316.                "Do you wish to over-write it ?") == FALSE) return;
  317.     }
  318.  
  319.     strcpy((char *)IODir->fr_HeadLine,"Load Gadget Render");
  320.     IODir->fr_Screen = MainScreen;
  321.     IODir->fr_Caller = MainWindow;
  322.     rc = FileRequest(IODir);
  323.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  324.     strcat((char *)&name,(char *)IODir->fr_FileName);
  325.  
  326.     if(rc == FREQ_CANCELED) return;
  327.     else if(rc)
  328.     {   Error("FileRequester Won't Open !");
  329.         return;
  330.     }
  331.     Saved = FALSE;
  332.     disable_window();
  333.     if(NOT(image = ReadImage(name)))
  334.     {   enable_window();
  335.         return;
  336.     }
  337.  
  338.     Pos = RemoveGList(MainWindow,gadget,1);
  339.     un_grel(MainWindow,gadget);
  340.     erase_gadget(MainWindow,gadget);
  341.  
  342.     if(TestBits((ULONG)gadget->Flags,GADGIMAGE))
  343.     {   image1 = (struct Image *)gadget->GadgetRender;
  344.         ps     = (ULONG)(RASSIZE(image1->Width,image1->Height) * image1->Depth);
  345.         FreeMem(image1->ImageData,ps);
  346.         FreeItem(&Memory,image1,(long)sizeof(struct Image));
  347.     }
  348.     else if(TestBits((ULONG)gadget->GadgetType,PROPGADGET))
  349.         FreeItem(&Memory,gadget->GadgetRender,(long)sizeof(struct Image));
  350.     else
  351.     {   border = (struct Border *)gadget->GadgetRender;
  352.         FreeItem(&Memory,border->XY,20L);
  353.         FreeItem(&Memory,border,(long)sizeof(struct Border));
  354.     }
  355.     if(NOT(TestBits((ULONG)gadget->GadgetType,PROPGADGET)))
  356.     {   if(prefs.auto_size)
  357.         {   gadget->Width  = image->Width;
  358.             gadget->Height = image->Height;
  359.         }
  360.     }
  361.     else
  362.     {   info = (struct PropInfo *)gadget->SpecialInfo;
  363.         info->Flags ^= AUTOKNOB;
  364.     }
  365.     gadget->Flags       |= GADGIMAGE;
  366.     gadget->GadgetRender = (APTR)image;
  367.     grel(MainWindow,gadget);
  368.     AddGList(MainWindow,gadget,Pos,1,NULL);
  369.     enable_window();
  370.     refresh();
  371. }
  372.  
  373. /*
  374.  * read an IFF ILBM brush as select render
  375.  */
  376. VOID sel_render()
  377. {
  378.     struct Gadget   *gadget;
  379.     struct PropInfo *info;
  380.     struct Image    *image, *image1, *ReadImage();
  381.     ULONG           Pos, ps, rc;
  382.  
  383.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  384.     if(NOT is_gadget()) return;
  385.     sst("PICK GADGET TO SELECT RENDER.....");
  386.     if(NOT(gadget = wait_for_gadget(MainWindow))) return;
  387.  
  388.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  389.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  390.     {   if(Ask("Gadget already has an Image !",
  391.                "Do you wish to over-write it ?") == FALSE) return;
  392.     }
  393.  
  394.     if(NOT(TestBits((ULONG)gadget->Flags,GADGIMAGE)))
  395.     {   Error("Not an Image Gadget !");
  396.         return;
  397.     }
  398.  
  399.     strcpy((char *)IODir->fr_HeadLine,"Load Select Render");
  400.     IODir->fr_Screen = MainScreen;
  401.     IODir->fr_Caller = MainWindow;
  402.     rc = FileRequest(IODir);
  403.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  404.     strcat((char *)&name,(char *)IODir->fr_FileName);
  405.     if(rc == FREQ_CANCELED) return;
  406.     else if(rc)
  407.     {   Error("FileRequester Won't Open");
  408.         return;
  409.     }
  410.  
  411.     Saved = FALSE;
  412.  
  413.     disable_window();
  414.     if(NOT(image = ReadImage(name)))
  415.     {   enable_window();
  416.         return;
  417.     }
  418.     Pos = RemoveGList(MainWindow,gadget,1);
  419.     un_grel(MainWindow,gadget);
  420.     erase_gadget(MainWindow,gadget);
  421.     if((TestBits((ULONG)gadget->Flags,GADGHBOX)) AND
  422.        (NOT TestBits((ULONG)gadget->Flags,GADGHIMAGE)))
  423.            gadget->Flags ^= GADGHBOX;
  424.  
  425.     if((TestBits((ULONG)gadget->Flags,GADGHIMAGE)) AND
  426.        (NOT TestBits((ULONG)gadget->Flags,GADGHBOX)))
  427.     {   image1 = (struct Image *)gadget->SelectRender;
  428.         ps     = (ULONG)(RASSIZE(image1->Width,image1->Height) * image1->Depth);
  429.         FreeMem(image1->ImageData,ps);
  430.         FreeItem(&Memory,image1,(long)sizeof(struct Image));
  431.     }
  432.  
  433.     gadget->Flags       |= GADGHIMAGE;
  434.     gadget->SelectRender = (APTR)image;
  435.     grel(MainWindow,gadget);
  436.     AddGList(MainWindow,gadget,Pos,1,NULL);
  437.     enable_window();
  438.     refresh();
  439. }
  440.  
  441. /*
  442.  * read and set the CMAP of an IFF ILBM picture
  443.  */
  444. VOID do_cmap()
  445. {
  446.     ULONG rc;
  447.  
  448.     strcpy((char *)IODir->fr_HeadLine,"Load IFF ColorMap");
  449.     IODir->fr_Screen = MainScreen;
  450.     IODir->fr_Caller = MainWindow;
  451.     rc = FileRequest(IODir);
  452.     strcpy((char *)&name,(char *)IODir->fr_DirName);
  453.     strcat((char *)&name,(char *)IODir->fr_FileName);
  454.     if(rc == FREQ_CANCELED) return;
  455.     else if(rc)
  456.     {   Error("FileRequester Won't Open !");
  457.         return;
  458.     }
  459.     Saved = FALSE;
  460.     disable_window();
  461.     ReadCMAP(name);
  462.     enable_window();
  463. }
  464.  
  465. /*
  466.  * resize a gadget
  467.  */
  468. VOID size_gadget()
  469. {
  470.     struct MyGadget *mg;
  471.     struct Gadget *gadget;
  472.     SHORT         x,y,w,h,xo,yo, *XY;
  473.     ULONG         Pos;
  474.  
  475.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  476.     add_bo();
  477.     sst("PICK GADGET TO RE-SIZE.....");
  478.     if(NOT(gadget = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  479.  
  480.     Saved = FALSE;
  481.  
  482.     mg = get_mg(gadget);
  483.     un_grel(MainWindow,gadget);
  484.     x = gadget->LeftEdge-1;
  485.     y = gadget->TopEdge-1;
  486.     w = gadget->Width+1;
  487.     h = gadget->Height+1;
  488.     set_info();
  489.     SetDrMd(MainRP,COMPLEMENT);
  490.     SetAPen(MainRP,FrontPen);
  491.     draw_box(MainWindow,x,y,x+w,y+h);
  492.     do_info(x,y,x+w,y+h);
  493.     xo = (x+w)-MainX;
  494.     yo = (y+h)-MainY;
  495.  
  496.     rem_bo();
  497.     if(NOT TestBits((ULONG)mg->SpecialFlags,BORDERONLY))
  498.         Pos = RemoveGList(MainWindow,gadget,1);
  499.     while(Code != SELECTDOWN)
  500.     {   while(read_msg(MainWindow))
  501.         {   if(Class == MENUPICK) set_info();
  502.             do_info(x,y,x+w,y+h);
  503.         }
  504.         get_xy(&MainX,&MainY);
  505.         if((MainX != ((x + w) - xo)) OR (MainY != ((y + h) - yo)))
  506.         {   draw_box(MainWindow,x,y,x+w,y+h);
  507.             if(((MainX - x) + xo) >= 9)  w = (MainX - x) + xo;
  508.             if(((MainY - y) + yo) >= 9)  h = (MainY - y) + yo;
  509.             draw_box(MainWindow,x,y,x+w,y+h);
  510.             do_info(x,y,x+w,y+h);
  511.         }
  512.     }
  513.     add_bo();
  514.     draw_box(MainWindow,x,y,x+w,y+h);
  515.     erase_gadget(MainWindow,gadget);
  516.     gadget->Width  = w-1;
  517.     gadget->Height = h-1;
  518.     if(NOT(TestBits((ULONG)gadget->GadgetType,PROPGADGET)))
  519.     {   XY = (((struct Border *)gadget->GadgetRender)->XY);
  520.         XY[2] = XY[4] = w-1;
  521.         XY[5] = XY[7] = h-1;
  522.     }
  523.     grel(MainWindow,gadget);
  524.     if(NOT TestBits((ULONG)mg->SpecialFlags,BORDERONLY))
  525.         AddGList(MainWindow,gadget,Pos,1,NULL);
  526.     rem_bo();
  527.     refresh();
  528. }
  529.  
  530. /*
  531.  * move a gadget
  532.  */
  533. VOID move_gadget()
  534. {
  535.     struct MyGadget *mg;
  536.     struct Gadget *gadget;
  537.     SHORT x,y,w,h,xo,yo;
  538.     ULONG Pos;
  539.  
  540.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  541.     add_bo();
  542.     sst("PICK GADGET TO MOVE....");
  543.     if(NOT(gadget = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  544.  
  545.     Saved = FALSE;
  546.     mg = get_mg(gadget);
  547.     set_info();
  548.     un_grel(MainWindow,gadget);
  549.     x = gadget->LeftEdge-1;
  550.     y = gadget->TopEdge-1;
  551.     w = gadget->Width+1;
  552.     h = gadget->Height+1;
  553.     SetDrMd(MainRP,COMPLEMENT);
  554.     SetAPen(MainRP,FrontPen);
  555.     draw_box(MainWindow,x,y,x+w,y+h);
  556.     do_info(x,y,x+w,y+h);
  557.     xo = MainX-x;
  558.     yo = MainY-y;
  559.  
  560.     rem_bo();
  561.     if(NOT TestBits((ULONG)mg->SpecialFlags,BORDERONLY))
  562.         Pos = RemoveGList(MainWindow,gadget,1);
  563.     while(Code != SELECTDOWN)
  564.     {   while(read_msg(MainWindow))
  565.         {   if(Class == MENUPICK) set_info();
  566.             do_info(x,y,x+w,y+h);
  567.         }
  568.         get_xy(&MainX,&MainY);
  569.         if((MainX != (x + xo)) OR (MainY != (y + yo)))
  570.         {   draw_box(MainWindow,x,y,x+w,y+h);
  571.             x = MainX - xo;
  572.             y = MainY - yo;
  573.             draw_box(MainWindow,x,y,x+w,y+h);
  574.             do_info(x,y,x+w,y+h);
  575.         }
  576.     }
  577.     add_bo();
  578.     draw_box(MainWindow,x,y,x+w,y+h);
  579.     erase_gadget(MainWindow,gadget);
  580.     gadget->LeftEdge = x+1;
  581.     gadget->TopEdge  = y+1;
  582.     grel(MainWindow,gadget);
  583.     if(NOT TestBits((ULONG)mg->SpecialFlags,BORDERONLY))
  584.         AddGList(MainWindow,gadget,Pos,1,NULL);
  585.     rem_bo();
  586.     refresh();
  587. }
  588.  
  589. /*
  590.  * edit a gadget
  591.  */
  592. VOID edit()
  593. {
  594.     struct MyGadget *mg;
  595.     struct Gadget   *g;
  596.     ULONG  Pos;
  597.     BOOL   suc;
  598.  
  599.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  600.     add_bo();
  601.     sst("PICK GADGET TO EDIT....");
  602.     if(NOT(g = wait_for_gadget(MainWindow))) { rem_bo(); return; }
  603.  
  604.     Saved = FALSE;
  605.  
  606.     mg = get_mg(g);
  607.     Pos = RemoveGList(MainWindow,g,1);
  608.     un_grel(MainWindow,g);
  609.     disable_window();
  610.     suc = edit_gadget(mg);
  611.     enable_window();
  612.     erase_gadget(MainWindow,g);
  613.     grel(MainWindow,g);
  614.     if(NOT suc)
  615.     {   Remove((void *)mg);
  616.         FreeGadget(mg);
  617.     }
  618.     else AddGList(MainWindow,g,Pos,1,NULL);
  619.     rem_bo();
  620.     refresh();
  621. }
  622.  
  623. /*
  624.  * erase all gadgets and set the window to default
  625.  */
  626. VOID new()
  627. {
  628.     if(Saved == FALSE)
  629.     {   if(Ask("Current work isn't saved !",
  630.                "Are you sure ?") == FALSE) return;
  631.     }
  632.  
  633.     FreeGList();
  634.  
  635.     if(REQUESTER)
  636.     {   nw_main.Flags     = WINDOWDRAG+WINDOWSIZING+SIZEBRIGHT+SIZEBBOTTOM+BORDERLESS+GIMMEZEROZERO;
  637.         strcpy((char *)&wdt,"Requester");
  638.         strcpy((char *)&wlb,"requester");
  639.         BackFill = 1;
  640.     }
  641.     else
  642.     {   nw_main.Flags    = WINDOWDRAG+WINDOWSIZING+WINDOWDEPTH+WINDOWCLOSE;
  643.         strcpy((char *)&wdt,"Work Window");
  644.         strcpy((char *)&wlb,"new_window");
  645.     }
  646.     nw_main.LeftEdge    = 50;
  647.     nw_main.TopEdge     = 25;
  648.     nw_main.Width       = 175;
  649.     nw_main.Height      = 50;
  650.     nw_main.BlockPen    = 1;
  651.     nw_main.DetailPen   = 0;
  652.     nw_main.FirstGadget = NULL;
  653.     nw_main.Title       = (UBYTE *)&wdt;
  654.     nw_main.MinWidth    = 150;
  655.     nw_main.MinHeight   = 50;
  656.     nw_main.MaxWidth    = MainScreen->Width;
  657.     nw_main.MaxHeight   = MainScreen->Height;
  658.     nw_main.Flags      |= NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  659.  
  660.     WindowFlags = WINDOWCLOSE+WINDOWDRAG+WINDOWDEPTH+WINDOWSIZING+NOCAREREFRESH+SMART_REFRESH+ACTIVATE;
  661.     IDCMPFlags  = GADGETUP+GADGETDOWN+CLOSEWINDOW;
  662.     CloseWindow(MainWindow);
  663.     open_display();
  664.     SetMenu(MainWindow);
  665.     if(!WBSCREEN)
  666.         LoadRGB4(&MainScreen->ViewPort,(void *)&Colors,(1 << DEPTH));
  667.     refresh();
  668. }
  669.  
  670. /*
  671.  * delete the render images of a gadget
  672.  */
  673. VOID delete_images()
  674. {
  675.     struct Gadget   *g;
  676.     struct Image    *i;
  677.     struct PropInfo *p;
  678.     ULONG            pos,ds;
  679.  
  680.     if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  681.     if(NOT is_gadget()) return;
  682.     sst("PICK GADGET TO DELETE IMAGES....");
  683.     if(NOT(g = wait_for_gadget(MainWindow))) return;
  684.  
  685.     if(NOT(TestBits((ULONG)g->Flags,GADGIMAGE)))
  686.     {   Error("Gadget has no Images to delete !");
  687.         return;
  688.     }
  689.  
  690.     Saved = FALSE;
  691.  
  692.     pos = RemoveGList(MainWindow,g,1);
  693.     un_grel(MainWindow,g);
  694.     i = (struct Image *)g->GadgetRender;
  695.     ds = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  696.     FreeMem(i->ImageData,ds);
  697.     if(NOT TestBits(g->GadgetType,PROPGADGET))
  698.        FreeItem(&Memory,i,(long)sizeof(struct Image));
  699.     g->Flags ^= GADGIMAGE;
  700.     if((TestBits((ULONG)g->Flags,GADGHIMAGE)) AND
  701.        (NOT TestBits((ULONG)g->Flags,GADGHBOX)))
  702.     {   i = (struct Image *)g->SelectRender;
  703.         ds = (ULONG)(RASSIZE(i->Width,i->Height) * i->Depth);
  704.         FreeMem(i->ImageData,ds);
  705.         FreeItem(&Memory,i,(long)sizeof(struct Image));
  706.         g->Flags ^= GADGHIMAGE;
  707.         g->SelectRender = NULL;
  708.     }
  709.     if(TestBits((ULONG)g->GadgetType,PROPGADGET))
  710.     {   p = (struct PropInfo *)g->SpecialInfo;
  711.         p->Flags |= AUTOKNOB;
  712.     }
  713.     else add_border(g);
  714.     erase_gadget(MainWindow,g);
  715.     grel(MainWindow,g);
  716.     AddGList(MainWindow,g,pos,1,NULL);
  717.     refresh();
  718. }
  719.  
  720. /*
  721.  * add a text to a gadget or the window/requester
  722.  */
  723. VOID add_text(which)
  724.     USHORT which;
  725. {
  726.     struct Gadget *g;
  727.     struct IntuiText *t, *edit_text();
  728.     ULONG pos;
  729.     SHORT x,y;
  730.  
  731.     if(NOT which)
  732.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  733.         if(NOT is_gadget()) return;
  734.         sst("PICK GADGET TO ADD TEXT....");
  735.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  736.         pos = RemoveGList(MainWindow,g,1);
  737.     }
  738.     else g = &TextGadget;
  739.  
  740.     if(NOT(t = edit_text(g,0,0,which)))
  741.     {   if(NOT which) AddGList(MainWindow,g,pos,1,NULL);
  742.         return;
  743.     }
  744.  
  745.     Saved = FALSE;
  746.  
  747.     un_grel(MainWindow,g);
  748.     get_xy(&x,&y);
  749.     SetDrMd(MainRP,COMPLEMENT);
  750.     SetAPen(MainRP,FrontPen);
  751.     Move(MainRP,x,y);
  752.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  753.  
  754.     while(Code != SELECTDOWN)
  755.     {   while(read_msg(MainWindow));
  756.         get_xy(&MainX,&MainY);
  757.         if((MainX != x) OR (MainY != y))
  758.         {   Move(MainRP,x,y);
  759.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  760.             x = MainX;
  761.             y = MainY;
  762.             Move(MainRP,x,y);
  763.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  764.         }
  765.     }
  766.     Move(MainRP,x,y);
  767.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  768.  
  769.     t->LeftEdge = x - g->LeftEdge;
  770.     t->TopEdge  = y - g->TopEdge - 6;
  771.  
  772.     if(NOT which)
  773.     {   erase_gadget(MainWindow,g);
  774.         grel(MainWindow,g);
  775.         AddGList(MainWindow,g,pos,1,NULL);
  776.     }
  777.     refresh();
  778. }
  779.  
  780. /*
  781.  * move a gadget or window/requester text
  782.  */
  783. VOID move_text(which)
  784.     USHORT which;
  785. {
  786.     struct Gadget    *g;
  787.     struct IntuiText *t, *GetPtr();
  788.     ULONG            pos;
  789.     LONG             tnum;
  790.     SHORT            x,y;
  791.  
  792.     if(NOT which)
  793.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  794.         if(NOT is_gadget()) return;
  795.         sst("PICK GADGET TO MOVE TEXT....");
  796.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  797.     }
  798.     else g = &TextGadget;
  799.  
  800.     if(NOT g->GadgetText)
  801.     {   if(NOT which) Error("Gadget has no text(s) to move !");
  802.         else if(which == 1) Error("Window has no text(s) to move !");
  803.         else Error("Requester has no text(s) to move !");
  804.         return;
  805.     }
  806.     if((tnum = text_select(g,1,which)) == -1L) return;
  807.  
  808.     Saved = FALSE;
  809.     t = GetPtr(g,tnum);
  810.  
  811.     if(NOT which) pos = RemoveGList(MainWindow,g,1);
  812.     un_grel(MainWindow,g);
  813.     get_xy(&x,&y);
  814.     SetDrMd(MainRP,COMPLEMENT);
  815.     SetAPen(MainRP,FrontPen);
  816.     Move(MainRP,x,y);
  817.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  818.  
  819.     while(Code != SELECTDOWN)
  820.     {   while(read_msg(MainWindow));
  821.         get_xy(&MainX,&MainY);
  822.         if((MainX != x) OR (MainY != y))
  823.         {   Move(MainRP,x,y);
  824.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  825.             x = MainX;
  826.             y = MainY;
  827.             Move(MainRP,x,y);
  828.             Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  829.         }
  830.     }
  831.     Move(MainRP,x,y);
  832.     Text(MainRP,(char *)t->IText,strlen((char *)t->IText));
  833.     text_num = tnum;
  834.     clear_text(g);
  835.     t->LeftEdge = x - g->LeftEdge;
  836.     t->TopEdge  = y - g->TopEdge - 6;
  837.     if(NOT which)
  838.     {   erase_gadget(MainWindow,g);
  839.         grel(MainWindow,g);
  840.         AddGList(MainWindow,g,pos,1,NULL);
  841.     }
  842.     refresh();
  843. }
  844.  
  845. /*
  846.  * modify a gadget or window/requester text
  847.  */
  848. VOID modify(which)
  849.     USHORT which;
  850. {
  851.     struct Gadget *g;
  852.     ULONG pos;
  853.  
  854.     if(NOT which)
  855.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  856.         if(NOT is_gadget()) return;
  857.         sst("PICK GADGET TO MODIFY TEXT....");
  858.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  859.     }
  860.     else g = &TextGadget;
  861.  
  862.     if(NOT g->GadgetText)
  863.     {   if(NOT which) Error("Gadget has no text(s) to modify !");
  864.         else if(which == 1) Error("Window has no text(s) to modify !");
  865.         else Error("Requester has no text(s) to modify !");
  866.         return;
  867.     }
  868.     Saved = FALSE;
  869.     if(NOT which) pos = RemoveGList(MainWindow,g,1);
  870.     text_select(g,2,which);
  871.     if(NOT which)
  872.     {   un_grel(MainWindow,g);
  873.         erase_gadget(MainWindow,g);
  874.         grel(MainWindow,g);
  875.         AddGList(MainWindow,g,pos,1,NULL);
  876.     }
  877.     refresh();
  878. }
  879.  
  880. /*
  881.  * delete a gadget or window/requester text
  882.  */
  883. VOID text_delete(which)
  884.     USHORT which;
  885. {
  886.     struct Gadget *g;
  887.     ULONG pos;
  888.  
  889.     if(NOT which)
  890.     {   if(Gadgets.TailPred == (struct MyGadget *)&Gadgets) return;
  891.         if(NOT is_gadget()) return;
  892.         sst("PICK GADGET TO DELETE TEXT....");
  893.         if(NOT(g = wait_for_gadget(MainWindow))) return;
  894.     }
  895.     else g = &TextGadget;
  896.     if(NOT g->GadgetText)
  897.     {   if(NOT which) Error("Gadget has no text(s) to delete !");
  898.         else if(which == 1) Error("Window has no text(s) to delete !");
  899.         else Error("Requester has no text(s) to delete !");
  900.         return;
  901.     }
  902.     Saved = FALSE;
  903.     if(NOT which) pos = RemoveGList(MainWindow,g,1);
  904.     text_select(g,3,which);
  905.     if(NOT which)
  906.     {   un_grel(MainWindow,g);
  907.         erase_gadget(MainWindow,g);
  908.         grel(MainWindow,g);
  909.         AddGList(MainWindow,g,pos,1,NULL);
  910.     }
  911.     refresh();
  912. }
  913.